package com.s7.utils;

import android.content.Context;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by Administrator on 2017/5/8.
 * String 相关类型处理工具
 */
public class StringUtils {

    /**
     * @param context
     * @param str
     */
    public static void setToast(Context context, String str) {
        Toast.makeText(context, str, Toast.LENGTH_LONG).show();
    }

    /**
     * 字符串是否包含某个字符串
     * @param str
     * @param s
     * @return
     */
    public static boolean isContain(String str, String s) {
        return str.contains(s);
    }

    /**
     * 手机号是否合法
     * @param mobiles
     * @return
     */
    public static boolean isMobileNO(String mobiles) {
        Pattern p = Pattern.compile("^((13[0-9])|(14[0-9])|(15[0-9])|(16[0-9])|(17[0-9])|(18[0-9])|(19[0-9]))\\d{8}$");
        Matcher m = p.matcher(mobiles);
        return m.matches();
    }

    /**
     * 手机号用****号隐藏中间数字
     * @param phone
     * @return
     */
    public static String setHideMobileNO(String phone) {
        if (!TextUtils.isEmpty(phone)) {
            return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
        }
        return null;
    }

    /**
     * 邮箱用****号隐藏前面的字母
     * @return
     */
    public static String settingEmail(String email) {
        String emails = email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
        return emails;
    }

    /**
     * Map 集合转 字符串
     * @param map
     * @param sign 分隔符
     * @return 返回值: Map的所有值用sign隔开形成的字符串
     */
    public static String getString(Map<String, String> map, String sign) {
        if(map == null){
            return null;
        }
        Map.Entry entry;
        StringBuffer sb = new StringBuffer();
        for(Iterator iterator = map.entrySet().iterator(); iterator.hasNext();)
        {
            entry = (Map.Entry)iterator.next();
            sb.append(null==entry.getValue()?"":entry.getValue().toString()).append (iterator.hasNext() ? sign : "");
        }
        return sb.toString();
    }

    /**
     * List 集合转 字符串
     * @param list
     * @param sign 分隔符
     * @return
     */
    public static String getString(List<String> list, String sign) {
        if(list==null){
            return null;
        }
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for(String string :list) {
            if(first) {
                first = false;
            }else{
                result.append(sign);
            }
            result.append(string);
        }
        return result.toString();
    }

    /**
     * 字符串 转 List集合
     * @param str
     * @param flag 分割符
     * @return
     */
    public static List getList(String str, String flag) {
        if(str == null){
            return null;
        }
        String str2 = str.replace(" ", ""); //去掉所用空格
        List<String> list = Arrays.asList(str2.split(flag));
        return list;
    }

    /**
     * List去重
     * @param list
     * @return
     */
    public static List removeDuplicatListHashSet(List list) {
        HashSet h = new HashSet(list);
        list.clear();
        list.addAll(h);
        return list;
    }

    /**
     * List去重，保持顺序
     * @param list
     * @return
     */
    public static List removeDuplicateList(List list) {
        Set set = new HashSet();
        List newList = new ArrayList();
        for (Iterator iter = list.iterator(); iter.hasNext();) {
            Object element = iter.next();
            if (set.add(element))
                newList.add(element);
        }
        list.clear();
        list.addAll(newList);
        return list;
    }

    /**
     * 比较两个List集合是否相等
     * 注：
     *    1. 如果一个List的引用为null，或者其包含的元素个数为0，那么该List在本逻辑处理中都算作空；
     *    2. 泛型参数T涉及到对象，所以需要确保正确实现了对应对象的equal()方法。
     * @param datas1
     * @param datas2
     * @param <T>
     * @return
     */
    public static<T> boolean isListEqual(List<T> datas1, List<T> datas2) {
        /**
         * 两个list引用相同（包括两者都为空指针的情况）
         */
        if (datas1 == datas2) {
            return true;
        }

        /**
         * 两个list都为空（包括空指针、元素个数为0）
         */
        if ((datas1 == null && datas2 != null && datas2.size() == 0)
                || (datas2 == null && datas1 != null && datas1.size() == 0)) {
            return true;
        }

        /**
         * 两个list元素个数不相同
         */
        if (datas1.size() != datas2.size()) {
            return false;
        }

        /**
         * 两个list元素个数已经相同，再比较两者内容
         *   可以忽略list中的元素的顺序
         *    涉及到对象的比较是否相同时，确保实现了equals()方法
         */
        if (!datas1.containsAll(datas2)) {
            return false;
        }
        return true;
    }

    /**
     * 数组 转 List集合
     * @param str
     * @return
     */
    public static List getList(String[] str) {
        if(str == null){
            return null;
        }
        List<String> list = new ArrayList<>();
        list.addAll(Arrays.asList(str));
        return list;
    }

    /**
     * 多数组合并
     * @param data
     * @return
     */
    public static String[] concatString(String[]... data) {
        List<String> datas = new ArrayList<>();
        for (String[] result : data) {
            datas.addAll(Arrays.asList(result));
        }
        String[] array = datas.toArray(new String[datas.size()]);
        return array;
    }

}
